`:top
`!OpenMP`! ist eine seit 1997 gemeinschaftlich von mehreren `F33f`_`[Hardware`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hardware]`_`f- und `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`fherstellern entwickelte `F33f`_`[Programmierschnittstelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierschnittstelle]`_`f (API) für die Shared-Memory-Programmierung in `F33f`_`[C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f, `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f und `F33f`_`[Fortran`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fortran]`_`f auf `F33f`_`[Multiprozessor`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Multiprozessor]`_`f-`F33f`_`[Computern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computer]`_`f.
OpenMP parallelisiert Programme auf der Ebene von Schleifen, die in `F33f`_`[Threads`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Thread_(Informatik)]`_`f ausgeführt werden, und unterscheidet sich dadurch von anderen Ansätzen (z. B. `F33f`_`[MPI`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Message_Passing_Interface]`_`f), bei denen ganze Prozesse parallel laufen und durch Nachrichtenaustausch zusammenwirken.
Der OpenMP-Standard definiert dazu spezielle Compiler-Direktiven, die diesen dann anweisen z. B. die Abarbeitung einer `F33f`_`[for-Schleife`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=For-Schleife]`_`f auf mehrere Threads oder Prozessoren zu verteilen. Alternativ gibt es Bibliotheksfunktionen und Umgebungsvariablen für die OpenMP-Programmierung.
OpenMP ist zum Einsatz auf Systemen mit gemeinsamem Hauptspeicher („Shared-Memory“-Maschinen) gedacht (sogenannte `F33f`_`[UMA`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unified_Memory_Access]`_`f- und `F33f`_`[NUMA`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Non-Uniform_Memory_Access]`_`f-Systeme), während andere Ansätze wie `F33f`_`[Message Passing Interface`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Message_Passing_Interface]`_`f, `F33f`_`[PVM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Parallele_Virtuelle_Maschine]`_`f eher auf Multicomputern („Distributed-Memory“-Maschinen) aufsetzen. Bei modernen Supercomputern werden OpenMP und MPI (Message Passing Interface) oftmals zusammen eingesetzt. Dabei laufen auf einzelnen Shared-Memory-Clients OpenMP-Prozesse, die sich mittels MPI austauschen.
Eine Eigenschaft von OpenMP ist, dass (bis auf Ausnahmen) die Programme auch korrekt laufen, wenn der Compiler die OpenMP-Anweisungen (siehe unten im Beispiel) nicht kennt und als Kommentar bewertet (also ignoriert). Der Grund dafür ist, dass eine mit OpenMP für mehrere Threads aufgeteilte `B100`F9d9for`f`b-Schleife auch mit einem einzelnen Thread sequentiell abgearbeitet werden kann.
>>Contents
• `F0af`_`[Hauptbestandteile`#hauptbestandteile]`_`f
• `F0af`_`[Beispiel-Code`#beispiel-code]`_`f
• `F0af`_`[Implementation`#implementation]`_`f
• `F0af`_`[Weblinks`#weblinks]`_`f
• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f
-─
>>Hauptbestandteile
Die Hauptbestandteile von OpenMP sind Konstrukte zur Thread-Erzeugung, Lastverteilung auf mehrere `F33f`_`[Threads`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Thread_(Informatik)]`_`f, Verwaltung des Gültigkeitsbereiches von Daten, Synchronisation, Laufzeitroutinen und Umgebungsvariablen. Die Thread-Erzeugung: `*omp parallel`* teilt das Programm (den Originalthread) in mehrere Threads auf, sodass der vom Konstrukt eingeschlossene Programmteil parallel abgearbeitet wird. Der Original-Thread wird als „Master Thread“ bezeichnet und trägt die ID „0“.
Beispiel: Gibt „Hallo, Welt!“ mehrmals mittels mehrerer Threads aus (jeder Thread erzeugt eine Ausgabe).
`B100`F9d9#include <stdio.h>`f`b
`B100`F9d9`f`b
`B100`F9d9int main() {`f`b
`B100`F9d9#pragma omp parallel`f`b
`B100`F9d9 puts("Hallo, Welt!\\n");`f`b
`B100`F9d9`f`b
`B100`F9d9 return 0;`f`b
`B100`F9d9}`f`b
Die Konstrukte zur Lastverteilung bestimmen, wie nebenläufige, unabhängige Arbeitslast auf parallele Threads verteilt wird. `*Omp for`* und `*omp do`* teilen hierbei Schleifendurchläufe (möglichst) gleichmäßig auf alle Threads auf (Gebietsaufteilung, "data partitioning"). `*Sections`* verteilt aufeinander folgende, aber unabhängige Programmteile auf mehrere Threads (Funktionsaufteilung, "function partitioning") auf.
Beispiel: Initialisiert eine große Tabelle ("array") parallel, wobei jeder Thread einen Teil initialisiert (Gebietsaufteilung).
`B100`F9d9#define N 100000`f`b
`B100`F9d9`f`b
`B100`F9d9int main() {`f`b
`B100`F9d9 int a[N];`f`b
`B100`F9d9`f`b
`B100`F9d9#pragma omp parallel for`f`b
`B100`F9d9 for (int i = 0; i < N; ++i)`f`b
`B100`F9d9 a[i] = 2 * i;`f`b
`B100`F9d9`f`b
`B100`F9d9 return 0;`f`b
`B100`F9d9}`f`b
Die Verwaltung eines Gültigkeitsbereich bei Daten lässt sich mit unterschiedlichen Programmierungen beeinflussen. Bei Shared-Memory-Programmierung sind zunächst die meisten Daten in allen Threads sichtbar. Einige Programme benötigen private, also nur für einen Thread sichtbare, Daten, und den expliziten Austausch von Werten zwischen sequentiellen und parallelen Abschnitten. Dafür dienen in OpenMP die sogenannten `*Data Clauses`*. Der Typ `*shared`* beschreibt, dass Daten für alle Threads sichtbar und änderbar sind. Sie liegen für alle Threads an derselben Speicherstelle. Ohne weitere Angaben sind Daten gemeinsame Daten. Die einzige Ausnahme davon sind Schleifenvariablen. Bei `*private`* verfügt jeder Thread über eigene Kopien dieser Daten, welche nicht initialisiert werden. Die Werte werden nicht außerhalb des parallelen Abschnitts bewahrt. Der Typ `*private`* lässt sich nochmal in `*firstprivate`* und `*lastprivate`* unterteilen, welche sich auch kombinieren lassen. Bei ersterem sind die Daten private Daten, mit dem Unterschied, dass sie mit dem letzten Wert vor dem parallelen Abschnitt initialisiert werden. `*Lastprivate`* unterscheidet sich darin, dass der Thread, welcher die letzte Iteration ausführt, anschließend den Wert aus dem parallelen Abschnitt herauskopiert.
Außerdem gibt es noch den Typ `*threadprivate`* für globale Daten, die im parallelen Programmabschnitt jedoch als privat behandelt werden. Der globale Wert wird über den parallelen Abschnitt hinweg bewahrt. `*Copyin`* ist analog zu `*firstprivate`* für `*private`* Daten, allerdings für `*threadprivate`* Daten, welche nicht initialisiert werden. Mit `*Copyin`* wird der globale Wert explizit an die privaten Daten übertragen. Ein `*Copyout`* ist nicht notwendig, da der globale Wert bewahrt wird. Bei dem Typ `*reduction`* sind die Daten privat, werden jedoch am Ende auf einen globalen Wert zusammengefasst (reduziert). So lässt sich zum Beispiel die Summe aller Elemente eines `F33f`_`[Arrays`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Feld_(Datentyp)]`_`f parallel bestimmen (Beispiel in `F33f`_`[Fortran`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fortran]`_`f):
`B100`F9d9 !$OMP DO REDUCTION(+:s)`f`b
`B100`F9d9 do i=1,size(a)`f`b
`B100`F9d9 s = s + a(i)`f`b
`B100`F9d9 end do`f`b
Es werden verschiedene Konstrukte zur Synchronisation der Threads verwendet, wie z. B. `*Critical Section`*, wobei der eingeschlossene Programmabschnitt von allen Threads ausgeführt wird, allerdings niemals gleichzeitig oder `*Barrier`* welcher eine Barriere markiert, wo jeder Thread wartet, bis alle anderen Threads der Gruppe ebenfalls die Barriere erreicht haben. Der Befehl `*atomic`* ist analog zu `*critical section`*, jedoch mit dem Hinweis an den Compiler, spezielle Hardwarefunktionen zu benutzen. Der Compiler ist an diesen Hinweis nicht gebunden, er kann ihn ignorieren. Sinnvoll ist die Verwendung von `*atomic`* für das exklusive Aktualisieren von Daten. `*Flush`* markiert einen Synchronisationpunkt, an dem ein konsistentes Speicherabbild hergestellt werden muss. Private Daten werden in den Arbeitsspeicher zurückgeschrieben. `*Single`* bedeutet, dass der umschlossene Programmteil nur von dem Thread ausgeführt wird, welcher ihn zuerst erreicht, dies impliziert eine Barriere am Ende des Blocks und ist somit äquivalent mit `*Barrier`* an einer bestimmten Stelle. `*Master`* ist Analog zu `*single`* mit dem Unterschied, dass der umschlossene Programmteil vom Master Thread ausgeführt wird und am Ende des Blocks keine Barriere impliziert ist.
Bei diesen Prozessen werden Laufzeitroutinen benutzt, um zum Beispiel die Thread-Anzahl während der Laufzeit zu bestimmen und zu ermitteln, ob sich das Programm gerade im parallelen oder sequentiellen Zustand befindet.
`F33f`_`[Umgebungsvariablen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Umgebungsvariable]`_`f liefern in diesem Zusammenhang, Informationen wie zum Beispiel die Thread-ID. Durch gezieltes Verändern bestimmter Umgebungsvariablen lässt sich die Ausführung von OpenMP-Programmen verändern. So kann beispielsweise die Anzahl von Threads und die Schleifenparallelisierung zur Laufzeit beeinflusst werden.
>>Beispiel-Code
Der folgende Code veranschaulicht die parallele Ausführung einer for-Schleife mittels OpenMP. Je nach Anzahl der beteiligten Threads wird die Schleife in kleine Abschnitte unterteilt, die je einem Thread zugeordnet werden. Damit wird erreicht, dass alle Threads gleichzeitig rechnen.
`B100`F9d9#include <omp.h>`f`b
`B100`F9d9#include <stdio.h>`f`b
`B100`F9d9`f`b
`B100`F9d9int main() {`f`b
`B100`F9d9 omp_set_num_threads(4);`f`b
`B100`F9d9`f`b
`B100`F9d9#pragma omp parallel for`f`b
`B100`F9d9 for (int i = 0; i < 4; ++i) {`f`b
`B100`F9d9 const int id = omp_get_thread_num();`f`b
`B100`F9d9`f`b
`B100`F9d9 printf("Hello World from thread %d\\n", id);`f`b
`B100`F9d9`f`b
`B100`F9d9 // Nur im Master-Thread ausführen`f`b
`B100`F9d9 if (id == 0)`f`b
`B100`F9d9 printf("There are %d threads\\n", omp_get_num_threads());`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 return 0;`f`b
`B100`F9d9}`f`b
Beim Übersetzen muss man dem Compiler sagen, dass er die Pragma-Anweisungen beachten und notwendige Bibliotheken für die omp-Funktionen einbinden soll. Dies funktioniert bei `B100`F9d9gcc`f`b oder `B100`F9d9clang`f`b über die Option `B100`F9d9-fopenmp`f`b.
`B100`F9d9% gcc -fopenmp example.c -o example`f`b
`B100`F9d9% ./example`f`b
`B100`F9d9Hello World from thread 3`f`b
`B100`F9d9Hello World from thread 0`f`b
`B100`F9d9Hello World from thread 1`f`b
`B100`F9d9Hello World from thread 2`f`b
`B100`F9d9There are 4 threads`f`b
Statt die Anzahl der Threads im Programm festzulegen, kann man dies auch zur Laufzeit bestimmen. Dazu setzt man die Umgebungsvariable `B100`F9d9OMP_NUM_THREADS`f`b auf den gewünschten Wert.
`B100`F9d9% OMP_NUM_THREADS=4 ./example`f`b
`B100`F9d9Hello World from thread 3`f`b
`B100`F9d9Hello World from thread 0`f`b
`B100`F9d9Hello World from thread 1`f`b
`B100`F9d9Hello World from thread 2`f`b
`B100`F9d9There are 4 threads`f`b
>>Implementation
OpenMP ist in den meisten Compilern integriert.
• `F33f`_`[Microsoft Visual C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Visual_C++]`_`f 2005, 2008 und 2010 (Professional, Team System, Premium und Ultimate Edition),
• Intel Parallel Studio für verschiedene Prozessoren (OpenMP 3.1 ab Version 13),
• `F33f`_`[GCC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GNU_Compiler_Collection]`_`f ab Version 4.2 (OpenMP 4.0 ab Version 5.0`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f]),
• `F33f`_`[Clang`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Clang]`_`f/`F33f`_`[LLVM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=LLVM]`_`f (OpenMP 3.1 ab Version 3.6.1),
• Oracle Solaris Studio Compiler und Tools für Solaris OS (UltraSPARC und x86/x64) und Linux,
• Fortran, C und C++ Compiler der Portland Group (OpenMP 2.5),
• `F33f`_`[Gfortran`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GNU_Fortran]`_`f,
• IBM XL C/C++ compiler,
• Nanos Compiler
• Pelles C (OpenMP 3.1 ab Version 8)
>>Weblinks
• Offizielle Website
• Tutorial von OpenMP
• OpenMP-Programmiergrundlagen (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 11. November 2011 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*) (PDF; 80 kB) C-orientiert (deutsch)
• Einführungsvideos von Intel
• OpenMP Parallelität messen und visualisieren anhand eines C++ Routenplaners wird der `F33f`_`[Speedup`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Speedup]`_`f-Faktor ermittelt (von MyARM)
>>Einzelnachweise
`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f gcc.gnu.org
`c`F0af`_`[↑ Back to top`#top]`_`f`a